package avicit.bdp.dds.api.controller;

import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * @金航数码科技有限责任公司
 * @作者：developer
 * @邮箱：developer@avic-digital.com
 * @创建时间： 2020-06-24 14:54
 * @类说明：ProcessDefinitionRest
 * @修改记录：
 * @注意事项：如果加上@Transactional、@Rollback(true)注解之后，CMD不会真正存入MySQL，启动流程定义时，CMD表中无数据，无法生成processInstance， 所以，本TestCase都是手动清理环境，异常场景下DB中可能存在脏数据；
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class ExecutorRestTest {
//    @Autowired
//    ExecutorRest executorRest;
//
//    @Autowired
//    ProcessDefinitionRest processDefinitionRest;
//
//    @Autowired
//    ProcessDefinitionMapper processDefinitionMapper;
//
//    @Autowired
//    private ProcessInstanceMapper processInstanceMapper;
//
//    // 使用JUnit框架中的ExpectedException类，用于测试异常;
//    @Rule
//    public ExpectedException thrown= ExpectedException.none();
//
//    private static ProcessDefinition processDefeCreate;
//
//    /**
//     * 所有用例执行前准备工作
//     */
//    @BeforeClass
//    public static void init() {
//        // step1:构造流程定义参数;
//        String processDefeStrCreate = "{\n" +
//                "    \"id\": \"d48644cc-2c7a-4714-9900-18ab99e80b77\",\n" +
//                "    \"name\": \"datax_job\",\n" +
//                "    \"releaseState\": \"1\",\n" +
//                "    \"projectId\": 456,\n" +
//                "\t\"typeId\": \"datax\",\n" +
//                "\t\"type\": 0,\n" +
//                "\t\"remark\": \"测试任务1\",\n" +
//                "\t\"datasourceId\": 1,\n" +
//                "\t\"processDefinitionJson\": \"{\\\"globalParams\\\":[],\\\"tasks\\\":[{\\\"type\\\":\\\"DATAX\\\",\\\"id\\\":\\\"tasks-24986\\\",\\\"name\\\":\\\"test\\\",\\\"params\\\":{\\\"customConfig\\\":0,\\\"dsType\\\":\\\"MYSQL\\\",\\\"dataSource\\\":1,\\\"dtType\\\":\\\"MYSQL\\\",\\\"dataTarget\\\":1,\\\"sql\\\":\\\"select * from db1;\\\",\\\"targetTable\\\":\\\"db2\\\",\\\"jobSpeedByte\\\":0,\\\"jobSpeedRecord\\\":1000,\\\"preStatements\\\":[],\\\"postStatements\\\":[]},\\\"description\\\":\\\"\\\",\\\"runFlag\\\":\\\"NORMAL\\\",\\\"conditionResult\\\":{\\\"successNode\\\":[\\\"\\\"],\\\"failedNode\\\":[\\\"\\\"]},\\\"dependence\\\":{},\\\"maxRetryTimes\\\":\\\"0\\\",\\\"retryInterval\\\":\\\"1\\\",\\\"timeout\\\":{\\\"strategy\\\":\\\"\\\",\\\"interval\\\":null,\\\"enable\\\":false},\\\"taskInstancePriority\\\":\\\"MEDIUM\\\",\\\"workerGroup\\\":\\\"default\\\",\\\"preTasks\\\":[]}],\\\"tenantId\\\":1,\\\"timeout\\\":0}\",\n" +
//                "\t\"locations\": \"{\\\"tasks-34878\\\":{\\\"name\\\":\\\"datax自定义模板测试\\\",\\\"targetarr\\\":\\\"\\\",\\\"nodenumber\\\":\\\"0\\\",\\\"x\\\":424,\\\"y\\\":312}}\",\n" +
//                "\t\"createdBy\": \"dcs\",\n" +
//                "\t\"createdDate\": \"2020-08-04 11:23:17\",\n" +
//                "\t\"lastUpdatedBy\":\"dcs\",\n" +
//                "\t\"lastUpdateDate\": \"2020-08-04 11:23:17\"\n" +
//                "}";
//        processDefeCreate = JSONUtils.parseObject(processDefeStrCreate, ProcessDefinition.class);
//
//        // step2:启动master进程；（定期拉去CMD表，生成processInstance）
//        String[] args = new String[0];
//        MasterServer.main(args);
//    }
//
//    /**
//     * 单个测试用例运行前准备工作
//     */
//    @Before
//    public void setUp() {
//        // TODO:
//    }
//
//    /**
//     * 单个测试用例运行后销毁工作
//     */
//    @After
//    public void tearDown() {
//        // TODO:
//    }
//
//    /**
//     * 所有用例执行完成后准备工作
//     */
//    @AfterClass
//    public static void destory() {
//        // TODO:
//    }
//
//    /**
//     * 预先创建流程定义；
//     *
//     * @throws RuntimeException
//     */
//    public void createProcessDefe() throws RuntimeException {
//        try {
//            ResponseMsg<Boolean> responseMsg = processDefinitionRest.createProcessDefinition(processDefeCreate);
//            if (!"200".equals(responseMsg.getRetCode())) {
//                System.out.println("Create processDefe failed.");
//                throw new RuntimeException("Create processDefe failed.");
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//            throw new RuntimeException(e);
//        }
//    }
//
//    /**
//     * 预先上线流程定义；
//     *
//     * @throws RuntimeException
//     */
//    public void releaseProcessDefe(int releaseState) throws RuntimeException {
//        try {
//            ResponseMsg<Boolean> responseMsg = processDefinitionRest.releaseProcessDefinition(processDefeCreate.getId(), releaseState);
//            if (!"200".equals(responseMsg.getRetCode())) {
//                System.out.println("Release processDefe failed.");
//                throw new RuntimeException("Release processDefe failed.");
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//            throw new RuntimeException(e);
//        }
//    }
//
//    /**
//     * 启动流程定义；
//     */
//    public void startProcIns() throws Exception {
//        ExecutorQuery executorQuery = new ExecutorQuery();
//        executorQuery.setProcessDefinitionId(processDefeCreate.getId());
//        executorQuery.setScheduleTime("");
//        executorQuery.setFailureStrategy(0);
//        executorQuery.setStartNodeList(null);
//        executorQuery.setTaskDependType(2);
//        executorQuery.setExecType(1);
//        executorQuery.setWarningType(2);
//        executorQuery.setWarningUserIds("avicit2015");
//        executorQuery.setRunMode(1);
//        executorQuery.setProcessInstancePriority(2);
//        executorQuery.setWorkerGroup(null);
//        executorQuery.setTimeout(null);
//
//        System.out.println(JSONUtils.toJsonString(executorQuery));
//
//        // todo set value
//
////        ResponseMsg<Boolean> responseMsg = executorRest.startProcessInstance(executorQuery);
////        Assert.assertEquals("200", responseMsg.getRetCode());
//    }
//
//    /**
//     * 用例执行完毕后删除流程定义；
//     *
//     * @throws RuntimeException
//     */
//    public void deleteProcessDefe() throws RuntimeException {
//        try {
//            ResponseMsg<Boolean> responseMsg = processDefinitionRest.deleteProcessDefinitionById(processDefeCreate.getId());
//            if (!"200".equals(responseMsg.getRetCode())) {
//                System.out.println("Delete processDefe failed.");
//                throw new RuntimeException("Delete processDefe failed.");
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//            throw new RuntimeException(e);
//        }
//    }
//
//    /**
//     * 用例执行完后删除流程实例；
//     *
//     * @throws RuntimeException
//     */
//    public void deleteProcessInstance() throws RuntimeException {
//        try {
//            List<ProcessInstance> processInstances = processInstanceMapper.queryByProcessDefineId(processDefeCreate.getId(), 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//
//            for (ProcessInstance processInstance : processInstances) {
//                int ret = processInstanceMapper.deleteByPrimaryKey(processInstance.getId());
//                if (ret <= 0) {
//                    throw new RuntimeException("Delete processInstance " + processInstance.getId() + " failed.");
//                }
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//            throw new RuntimeException(e);
//        }
//    }
//
//    /***************************************************************
//     ******************       正常场景测试用例       ******************
//     ***************************************************************/
//    /**
//     * 启动工作流；
//     *
//     * @throws Exception
//     */
//    @TestUtil(timeout = 60 * 1000)
//    public void testStartProcessInstance_1() throws Exception {
//        try {
//            // step1:准备阶段:（1）创建流程定义（2）发布流程定义
//            createProcessDefe();
//            //releaseProcessDefe(1);
//
//            // step1_2:启动流程实例参数；
//            String processDefinitionId = processDefeCreate.getId();
//            String scheduleTime = "";
//            FailureStrategy failureStrategy = FailureStrategy.CONTINUE;
//            String startNodeList = null;
//            TaskDependType taskDependType = TaskDependType.TASK_POST;
//            CommandType execType = CommandType.START_CURRENT_TASK_PROCESS;
//            WarningType warningType = WarningType.FAILURE;
//            String warningUserIds = "avicit2015";
//            RunMode runMode = RunMode.RUN_MODE_SERIAL;
//            Priority processInstancePriority = Priority.MEDIUM;
//            String workerGroup = null;
//            Integer timeout = null;
//
//            ExecutorQuery executorQuery = new ExecutorQuery();
//            // todo set value
//
//            // step2:执行阶段
//            ResponseMsg<Boolean> responseMsg = executorRest.startProcessInstance(executorQuery);
//
//            // step3:验证阶段：（1）验证启动流程执行结果（2）验证流程实例创建清空；
//            Assert.assertEquals("200", responseMsg.getRetCode());
//            // MasterSchedulerService线程每隔1s扫描一次CMD，此处等待2s，保证ProcessInstance被创建；
//            try {
//                Thread.sleep(3000);
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//            List<ProcessInstance> processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//        } finally {
//            // step4:清理阶段；（1）删除流程定义（2）下线流程实例（3）删除流程实例
//            //releaseProcessDefe(0);
//            deleteProcessInstance();
//            deleteProcessDefe();
//        }
//    }
//
//    /**
//     * 暂停工作流；
//     *
//     * @throws Exception
//     */
//    @TestUtil(timeout = 60 * 1000)
//    public void testExecute_1() throws Exception {
//        try {
//            // step1:准备阶段:（1）创建流程定义（2）发布流程定义（3）启动流程定义；
//            // step1_1:创建流程定义 and 上线流程定义
//            createProcessDefe();
//            releaseProcessDefe(1);
//
//            // step1_2:启动流程实例；
//            startProcIns();
//
//            // step1_3:查询启动后的流程实例ID；
//            // MasterSchedulerService线程每隔1s扫描一次CMD，此处等待2s，保证ProcessInstance被创建；
//            try {
//                Thread.sleep(3000);
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//
//            String processDefinitionId = processDefeCreate.getId();
//            List<ProcessInstance> processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            ProcessInstance processInstance = processInstances.get(0);
//
//            // step2:执行阶段
//            ResponseMsg<Boolean> responseMsg = executorRest.execute(processInstance.getId(), ExecuteType.PAUSE);
//
//            // step3:验证阶段；（1）验证暂停流程是否执行成功（2）验证流程实例状态；
//            Assert.assertEquals("200", responseMsg.getRetCode());
//            processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            processInstance = processInstances.get(0);
//            Assert.assertEquals(processInstance.getState(), ExecutionStatus.READY_PAUSE);
//        } finally {
//            // step4:清理阶段；（1）删除流程定义（2）下线流程实例（3）删除流程实例
//            releaseProcessDefe(0);
//            deleteProcessInstance();
//            deleteProcessDefe();
//        }
//    }
//
//    /**
//     * 终止工作流；
//     *
//     * @throws Exception
//     */
//    @TestUtil(timeout = 60 * 1000)
//    public void testExecute_2() throws Exception {
//        try {
//            // step1:准备阶段:（1）创建流程定义（2）发布流程定义（3）启动流程定义；
//            // step1_1:创建流程定义 and 上线流程定义
//            createProcessDefe();
//            releaseProcessDefe(1);
//
//            // step1_2:启动流程实例；
//            startProcIns();
//
//            // step1_3:查询启动后的流程实例ID；
//            // MasterSchedulerService线程每隔1s扫描一次CMD，此处等待2s，保证ProcessInstance被创建；
//            try {
//                Thread.sleep(3000);
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//
//            String processDefinitionId = processDefeCreate.getId();
//            List<ProcessInstance> processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            ProcessInstance processInstance = processInstances.get(0);
//
//            // step2:执行阶段
//            ResponseMsg<Boolean> responseMsg = executorRest.execute(processInstance.getId(), ExecuteType.STOP);
//
//            // step3:验证阶段；（1）验证暂停流程是否执行成功（2）验证流程实例状态；
//            Assert.assertEquals("200", responseMsg.getRetCode());
//            processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            processInstance = processInstances.get(0);
//            Assert.assertEquals(processInstance.getState(), ExecutionStatus.READY_STOP);
//        } finally {
//            // step4:清理阶段；（1）删除流程定义（2）下线流程实例（3）删除流程实例
//            releaseProcessDefe(0);
//            deleteProcessInstance();
//            deleteProcessDefe();
//        }
//    }
//
//    /**
//     * 重新启动工作流；
//     *
//     * @throws Exception
//     */
//    @TestUtil(timeout = 60 * 1000)
//    public void testExecute_3() throws Exception {
//        try {
//            // step1:准备阶段:（1）创建流程定义（2）发布流程定义（3）启动流程定义（4）修改ProcessInstance状态为Success，否则无法重新执行；
//            // step1_1:创建流程定义 and 上线流程定义
//            createProcessDefe();
//            releaseProcessDefe(1);
//
//            // step1_2:启动流程实例；
//            startProcIns();
//
//            // step1_3:查询启动后的流程实例ID；
//            // MasterSchedulerService线程每隔1s扫描一次CMD，此处等待2s，保证ProcessInstance被创建；
//            try {
//                Thread.sleep(3000);
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//
//            String processDefinitionId = processDefeCreate.getId();
//            List<ProcessInstance> processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            ProcessInstance processInstance = processInstances.get(0);
//
//            // step1_4:修改ProcessInstance状态为Success
//            processInstance.setState(ExecutionStatus.SUCCESS);
//            int ret = processInstanceMapper.updateByPrimaryKey(processInstance);
//            Assert.assertEquals(ret > 0, true);
//
//            // step2:执行阶段
//            ResponseMsg<Boolean> responseMsg = executorRest.execute(processInstance.getId(), ExecuteType.REPEAT_RUNNING);
//
//            // step3:验证阶段；（1）验证暂停流程是否执行成功（3）RepeatRunning会新建CMD，流程实例ID保持不变（3）验证流程实例状态；
//            Assert.assertEquals("200", responseMsg.getRetCode());
//
//            // MasterSchedulerService线程每隔1s扫描一次CMD，此处等待3s，保证ProcessInstance被创建；
//            try {
//                Thread.sleep(3000);
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//            processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            // index=0，表示重新running的instance；重新running的insId不会发生变化
//            ProcessInstance processInstanceRunning = processInstances.get(0);
//            Assert.assertEquals(processInstanceRunning.getState(), ExecutionStatus.RUNNING_EXEUTION);
//        } finally {
//            // step4:清理阶段；（1）删除流程定义（2）下线流程实例（3）删除流程实例
//            releaseProcessDefe(0);
//            deleteProcessInstance();
//            deleteProcessDefe();
//        }
//    }
//
//    /**
//     * 恢复暂停工作流;
//     *
//     * @throws Exception
//     */
//    @TestUtil(timeout = 60 * 1000)
//    public void testExecute_4() throws Exception {
//        try {
//            // step1:准备阶段:（1）创建流程定义（2）发布流程定义（3）启动流程定义（4）修改ProcessInstance状态为Pause，否则无法重新执行；
//            // step1_1:创建流程定义 and 上线流程定义
//            createProcessDefe();
//            releaseProcessDefe(1);
//
//            // step1_2:启动流程实例；
//            startProcIns();
//
//            // step1_3:查询启动后的流程实例ID；
//            // MasterSchedulerService线程每隔1s扫描一次CMD，此处等待2s，保证ProcessInstance被创建；
//            try {
//                Thread.sleep(3000);
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//
//            String processDefinitionId = processDefeCreate.getId();
//            List<ProcessInstance> processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            ProcessInstance processInstance = processInstances.get(0);
//
//            // step1_4:修改ProcessInstance状态为Pause
//            processInstance.setState(ExecutionStatus.PAUSE);
//            int ret = processInstanceMapper.updateByPrimaryKey(processInstance);
//            Assert.assertEquals(ret > 0, true);
//
//            // step2:执行阶段
//            ResponseMsg<Boolean> responseMsg = executorRest.execute(processInstance.getId(), ExecuteType.RECOVER_SUSPENDED_PROCESS);
//
//            // step3:验证阶段；（1）验证恢复流程是否执行成功（3）Recover会新建CMD，流程实例ID保持不变（3）验证流程实例状态；
//            Assert.assertEquals("200", responseMsg.getRetCode());
//
//            // MasterSchedulerService线程每隔1s扫描一次CMD，此处等待3s，保证ProcessInstance被创建；
//            try {
//                Thread.sleep(3000);
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//            processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            // index=0，表示重新running的instance；重新running的insId不会发生变化
//            ProcessInstance processInstanceRunning = processInstances.get(0);
//            Assert.assertEquals(processInstanceRunning.getState(), ExecutionStatus.RUNNING_EXEUTION);
//        } finally {
//            // step4:清理阶段；（1）删除流程定义（2）下线流程实例（3）删除流程实例
//            releaseProcessDefe(0);
//            deleteProcessInstance();
//            deleteProcessDefe();
//        }
//    }
//
//    /**
//     * 重启执行失败的流程实例；
//     *
//     * @throws Exception
//     */
//    @TestUtil(timeout = 60 * 1000)
//    public void testExecute_5() throws Exception {
//        try {
//            // step1:准备阶段:（1）创建流程定义（2）发布流程定义（3）启动流程定义（4）修改ProcessInstance状态为Failure，否则无法重新执行；
//            // step1_1:创建流程定义 and 上线流程定义
//            createProcessDefe();
//            releaseProcessDefe(1);
//
//            // step1_2:启动流程实例；
//            startProcIns();
//
//            // step1_3:查询启动后的流程实例ID；
//            // MasterSchedulerService线程每隔1s扫描一次CMD，此处等待2s，保证ProcessInstance被创建；
//            try {
//                Thread.sleep(3000);
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//
//            String processDefinitionId = processDefeCreate.getId();
//            List<ProcessInstance> processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            ProcessInstance processInstance = processInstances.get(0);
//
//            // step1_4:修改ProcessInstance状态为Pause
//            processInstance.setState(ExecutionStatus.FAILURE);
//            int ret = processInstanceMapper.updateByPrimaryKey(processInstance);
//            Assert.assertEquals(ret > 0, true);
//
//            // step2:执行阶段
//            ResponseMsg<Boolean> responseMsg = executorRest.execute(processInstance.getId(), ExecuteType.START_FAILURE_TASK_PROCESS);
//
//            // step3:验证阶段；（1）验证恢复流程是否执行成功（3）Recover会新建CMD，流程实例ID保持不变（3）验证流程实例状态；
//            Assert.assertEquals("200", responseMsg.getRetCode());
//
//            // MasterSchedulerService线程每隔1s扫描一次CMD，此处等待3s，保证ProcessInstance被创建；
//            try {
//                Thread.sleep(3000);
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//            processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            // index=0，表示重新running的instance；重新running的insId不会发生变化
//            ProcessInstance processInstanceRunning = processInstances.get(0);
//            Assert.assertEquals(processInstanceRunning.getState(), ExecutionStatus.RUNNING_EXEUTION);
//        } finally {
//            // step4:清理阶段；（1）删除流程定义（2）下线流程实例（3）删除流程实例
//            releaseProcessDefe(0);
//            deleteProcessInstance();
//            deleteProcessDefe();
//        }
//    }
//
//    /**
//     * DCS暂停流程实例；
//     *
//     * @throws Exception
//     */
//    @TestUtil(timeout = 60 * 1000)
//    public void testExecuteDcs_1() throws Exception {
//        try {
//            // step1:准备阶段:（1）创建流程定义（2）发布流程定义（3）启动流程定义；
//            // step1_1:创建流程定义 and 上线流程定义
//            createProcessDefe();
//            releaseProcessDefe(1);
//
//            // step1_2:启动流程实例；
//            startProcIns();
//
//            // step1_3:查询启动后的流程实例ID；
//            // MasterSchedulerService线程每隔1s扫描一次CMD，此处等待2s，保证ProcessInstance被创建；
//            try {
//                Thread.sleep(3000);
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//
//            String processDefinitionId = processDefeCreate.getId();
//            List<ProcessInstance> processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            ProcessInstance processInstance = processInstances.get(0);
//
//            // step2:执行阶段
//            ResponseMsg<Boolean> responseMsg = executorRest.executeDcs(processDefinitionId, ExecuteType.PAUSE);
//
//            // step3:验证阶段；（1）验证暂停流程是否执行成功（2）验证流程实例状态；
//            Assert.assertEquals("200", responseMsg.getRetCode());
//            processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            processInstance = processInstances.get(0);
//            Assert.assertEquals(processInstance.getState(), ExecutionStatus.READY_PAUSE);
//        } finally {
//            // step4:清理阶段；（1）删除流程定义（2）下线流程实例（3）删除流程实例
//            releaseProcessDefe(0);
//            deleteProcessInstance();
//            deleteProcessDefe();
//        }
//    }
//
//    /**
//     * DCS终止流程实例；
//     *
//     * @throws Exception
//     */
//    @TestUtil(timeout = 60 * 1000)
//    public void testExecuteDcs_2() throws Exception {
//        try {
//            // step1:准备阶段:（1）创建流程定义（2）发布流程定义（3）启动流程定义；
//            // step1_1:创建流程定义 and 上线流程定义
//            createProcessDefe();
//            releaseProcessDefe(1);
//
//            // step1_2:启动流程实例；
//            startProcIns();
//
//            // step1_3:查询启动后的流程实例ID；
//            // MasterSchedulerService线程每隔1s扫描一次CMD，此处等待2s，保证ProcessInstance被创建；
//            try {
//                Thread.sleep(3000);
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//
//            String processDefinitionId = processDefeCreate.getId();
//            List<ProcessInstance> processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            ProcessInstance processInstance = processInstances.get(0);
//
//            // step2:执行阶段
//            ResponseMsg<Boolean> responseMsg = executorRest.executeDcs(processDefinitionId, ExecuteType.STOP);
//
//            // step3:验证阶段；（1）验证暂停流程是否执行成功（2）验证流程实例状态；
//            Assert.assertEquals("200", responseMsg.getRetCode());
//            processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            processInstance = processInstances.get(0);
//            Assert.assertEquals(processInstance.getState(), ExecutionStatus.READY_STOP);
//        } finally {
//            // step4:清理阶段；（1）删除流程定义（2）下线流程实例（3）删除流程实例
//            releaseProcessDefe(0);
//            deleteProcessInstance();
//            deleteProcessDefe();
//        }
//    }
//
//    /**
//     * DCS重新启动流程实例；
//     *
//     * @throws Exception
//     */
//    @TestUtil(timeout = 60 * 1000)
//    public void testExecuteDcs_3() throws Exception {
//        try {
//            // step1:准备阶段:（1）创建流程定义（2）发布流程定义（3）启动流程定义（4）修改ProcessInstance状态为Success，否则无法重新执行；
//            // step1_1:创建流程定义 and 上线流程定义
//            createProcessDefe();
//            releaseProcessDefe(1);
//
//            // step1_2:启动流程实例；
//            startProcIns();
//
//            // step1_3:查询启动后的流程实例ID；
//            // MasterSchedulerService线程每隔1s扫描一次CMD，此处等待2s，保证ProcessInstance被创建；
//            try {
//                Thread.sleep(3000);
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//
//            String processDefinitionId = processDefeCreate.getId();
//            List<ProcessInstance> processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            ProcessInstance processInstance = processInstances.get(0);
//
//            // step1_4:修改ProcessInstance状态为Success
//            processInstance.setState(ExecutionStatus.SUCCESS);
//            int ret = processInstanceMapper.updateByPrimaryKey(processInstance);
//            Assert.assertEquals(ret > 0, true);
//
//            // step2:执行阶段
//            ResponseMsg<Boolean> responseMsg = executorRest.executeDcs(processDefinitionId, ExecuteType.REPEAT_RUNNING);
//
//            // step3:验证阶段；（1）验证暂停流程是否执行成功（3）RepeatRunning会新建CMD，流程实例ID保持不变（3）验证流程实例状态；
//            Assert.assertEquals("200", responseMsg.getRetCode());
//
//            // MasterSchedulerService线程每隔1s扫描一次CMD，此处等待3s，保证ProcessInstance被创建；
//            try {
//                Thread.sleep(3000);
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//            processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            // index=0，表示重新running的instance；重新running的insId不会发生变化
//            ProcessInstance processInstanceRunning = processInstances.get(0);
//            Assert.assertEquals(processInstanceRunning.getState(), ExecutionStatus.RUNNING_EXEUTION);
//        } finally {
//            // step4:清理阶段；（1）删除流程定义（2）下线流程实例（3）删除流程实例
//            releaseProcessDefe(0);
//            deleteProcessInstance();
//            deleteProcessDefe();
//        }
//    }
//
//    /**
//     * DCS恢复暂停的流程实例；
//     *
//     * @throws Exception
//     */
//    @TestUtil(timeout = 60 * 1000)
//    public void testExecuteDcs_4() throws Exception {
//        try {
//            // step1:准备阶段:（1）创建流程定义（2）发布流程定义（3）启动流程定义（4）修改ProcessInstance状态为Pause，否则无法重新执行；
//            // step1_1:创建流程定义 and 上线流程定义
//            createProcessDefe();
//            releaseProcessDefe(1);
//
//            // step1_2:启动流程实例；
//            startProcIns();
//
//            // step1_3:查询启动后的流程实例ID；
//            // MasterSchedulerService线程每隔1s扫描一次CMD，此处等待2s，保证ProcessInstance被创建；
//            try {
//                Thread.sleep(3000);
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//
//            String processDefinitionId = processDefeCreate.getId();
//            List<ProcessInstance> processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            ProcessInstance processInstance = processInstances.get(0);
//
//            // step1_4:修改ProcessInstance状态为Pause
//            processInstance.setState(ExecutionStatus.PAUSE);
//            int ret = processInstanceMapper.updateByPrimaryKey(processInstance);
//            Assert.assertEquals(ret > 0, true);
//
//            // step2:执行阶段
//            ResponseMsg<Boolean> responseMsg = executorRest.executeDcs(processDefinitionId, ExecuteType.RECOVER_SUSPENDED_PROCESS);
//
//            // step3:验证阶段；（1）验证恢复流程是否执行成功（3）Recover会新建CMD，流程实例ID保持不变（3）验证流程实例状态；
//            Assert.assertEquals("200", responseMsg.getRetCode());
//
//            // MasterSchedulerService线程每隔1s扫描一次CMD，此处等待3s，保证ProcessInstance被创建；
//            try {
//                Thread.sleep(3000);
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//            processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            // index=0，表示重新running的instance；重新running的insId不会发生变化
//            ProcessInstance processInstanceRunning = processInstances.get(0);
//            Assert.assertEquals(processInstanceRunning.getState(), ExecutionStatus.RUNNING_EXEUTION);
//        } finally {
//            // step4:清理阶段；（1）删除流程定义（2）下线流程实例（3）删除流程实例
//            releaseProcessDefe(0);
//            deleteProcessInstance();
//            deleteProcessDefe();
//        }
//    }
//
//    /**
//     * DCS重新执行失败的流程实例；
//     *
//     * @throws Exception
//     */
//    @TestUtil(timeout = 60 * 1000)
//    public void testExecuteDcs_5() throws Exception {
//        try {
//            // step1:准备阶段:（1）创建流程定义（2）发布流程定义（3）启动流程定义（4）修改ProcessInstance状态为Failure，否则无法重新执行；
//            // step1_1:创建流程定义 and 上线流程定义
//            createProcessDefe();
//            releaseProcessDefe(1);
//
//            // step1_2:启动流程实例；
//            startProcIns();
//
//            // step1_3:查询启动后的流程实例ID；
//            // MasterSchedulerService线程每隔1s扫描一次CMD，此处等待2s，保证ProcessInstance被创建；
//            try {
//                Thread.sleep(3000);
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//
//            String processDefinitionId = processDefeCreate.getId();
//            List<ProcessInstance> processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            ProcessInstance processInstance = processInstances.get(0);
//
//            // step1_4:修改ProcessInstance状态为Pause
//            processInstance.setState(ExecutionStatus.FAILURE);
//            int ret = processInstanceMapper.updateByPrimaryKey(processInstance);
//            Assert.assertEquals(ret > 0, true);
//
//            // step2:执行阶段
//            ResponseMsg<Boolean> responseMsg = executorRest.executeDcs(processDefinitionId, ExecuteType.START_FAILURE_TASK_PROCESS);
//
//            // step3:验证阶段；（1）验证恢复流程是否执行成功（3）Recover会新建CMD，流程实例ID保持不变（3）验证流程实例状态；
//            Assert.assertEquals("200", responseMsg.getRetCode());
//
//            // MasterSchedulerService线程每隔1s扫描一次CMD，此处等待3s，保证ProcessInstance被创建；
//            try {
//                Thread.sleep(3000);
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//            processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            // index=0，表示重新running的instance；重新running的insId不会发生变化
//            ProcessInstance processInstanceRunning = processInstances.get(0);
//            Assert.assertEquals(processInstanceRunning.getState(), ExecutionStatus.RUNNING_EXEUTION);
//        } finally {
//            // step4:清理阶段；（1）删除流程定义（2）下线流程实例（3）删除流程实例
//            releaseProcessDefe(0);
//            deleteProcessInstance();
//            deleteProcessDefe();
//        }
//    }
//
//    /***************************************************************
//     ******************       异常场景测试用例       ******************
//     ***************************************************************/
//    /**
//     * 启动工作流,超时时间不合法，启动失败；
//     *
//     * @throws Exception
//     */
//    @TestUtil(timeout = 60 * 1000)
//    public void testStartProcessInstance_1_1() throws Exception {
//        try {
//            // step1:准备阶段;（1）创建流程定义（2）上线流程定义
//            // step1_1:创建流程定义，并上线；
//            createProcessDefe();
//            releaseProcessDefe(1);
//
//            // step1_2:启动流程实例参数；
//            String processDefinitionId = processDefeCreate.getId();
//            String scheduleTime = "";
//            FailureStrategy failureStrategy = FailureStrategy.CONTINUE;
//            String startNodeList = null;
//            TaskDependType taskDependType = TaskDependType.TASK_POST;
//            CommandType execType = CommandType.START_CURRENT_TASK_PROCESS;
//            WarningType warningType = WarningType.FAILURE;
//            String warningUserIds = "avicit2015";
//            RunMode runMode = RunMode.RUN_MODE_SERIAL;
//            Priority processInstancePriority = Priority.MEDIUM;
//            String workerGroup = null;
//            Integer timeout = 25 * 3600;
//
//            ExecutorQuery executorQuery = new ExecutorQuery();
//            // todo set value
//
//            // step2:执行阶段
//            ResponseMsg<Boolean> responseMsg = executorRest.startProcessInstance(executorQuery);
//
//            // step3:验证阶段
//            Assert.assertEquals("200".equals(responseMsg.getRetCode()), false);
//        } finally {
//            // step4:清理阶段;（1）流程定义下线（2）删除流程定义
//            releaseProcessDefe(0);
//            deleteProcessDefe();
//        }
//    }
//
//    /**
//     * 启动工作流，流程定义不存在，启动失败；
//     *
//     * @throws Exception
//     */
//    @TestUtil(timeout = 60 * 1000)
//    public void testStartProcessInstance_1_2() throws Exception {
//        // step1:准备阶段
//        String processDefinitionId = processDefeCreate.getId();
//        String scheduleTime = "";
//        FailureStrategy failureStrategy = FailureStrategy.CONTINUE;
//        String startNodeList = null;
//        TaskDependType taskDependType = TaskDependType.TASK_POST;
//        CommandType execType = CommandType.START_CURRENT_TASK_PROCESS;
//        WarningType warningType = WarningType.FAILURE;
//        String warningUserIds = "avicit2015";
//        RunMode runMode = RunMode.RUN_MODE_SERIAL;
//        Priority processInstancePriority = Priority.MEDIUM;
//        String workerGroup = null;
//        Integer timeout = null;
//
//        ExecutorQuery executorQuery = new ExecutorQuery();
//        // todo set value
//
//        // step2:执行阶段
//        ResponseMsg<Boolean> responseMsg = executorRest.startProcessInstance(executorQuery);
//
//        // step3:验证阶段
//        Assert.assertEquals("200".equals(responseMsg.getRetCode()), false);
//
//        // step4:清理阶段
//    }
//
//    /**
//     * 启动工作流，Master节点不存在，启动失败；
//     *
//     * @throws Exception
//     */
//    @TestUtil(timeout = 60 * 1000)
//    public void testStartProcessInstance_1_3() throws Exception {
//        // step1:准备阶段
//
//        // step2:执行阶段
//
//        // step3:验证阶段
//
//        // step4:清理阶段
//    }
//
//    /**
//     * 启动工作流，创建CMD命令失败，启动失败；
//     *
//     * @throws Exception
//     */
//    @TestUtil(timeout = 60 * 1000)
//    public void testStartProcessInstance_1_4() throws Exception {
////        // step1:准备阶段
////        // step1_1:创建流程定义，并上线；
////        ResponseMsg<Boolean> responseMsg = processDefinitionRest.createProcessDefinition(processDefeCreate);
////        Assert.assertEquals("200",responseMsg.getRetCode());
////        responseMsg = processDefinitionRest.releaseProcessDefinition(processDefeCreate.getId(), 1);
////        Assert.assertEquals("200",responseMsg.getRetCode());
////
////        // step1_2:启动流程实例参数；
////        String processDefinitionId = processDefeCreate.getId();
////        String scheduleTime = "";
////        FailureStrategy failureStrategy = FailureStrategy.CONTINUE;
////        String startNodeList = null;
////        TaskDependType taskDependType = TaskDependType.TASK_POST;
////        CommandType execType = CommandType.START_CURRENT_TASK_PROCESS;
////        WarningType warningType = WarningType.FAILURE;
////        String warningUserIds = "avicit2015";
////        RunMode runMode = RunMode.RUN_MODE_SERIAL;
////        Priority processInstancePriority = Priority.MEDIUM;
////        String workerGroup = null;
////        Integer timeout = null;
////
////        // step2:执行阶段
////        responseMsg = executorRest.startProcessInstance(processDefinitionId, scheduleTime,
////                failureStrategy, startNodeList, taskDependType, execType, warningType, warningUserIds,
////                runMode, processInstancePriority, workerGroup, timeout);
////
////        // step3:验证阶段
////        Assert.assertEquals("200".equals(responseMsg.getRetCode()), false);
////
////        // step4:清理阶段;（1）流程定义下线（2）删除流程定义
////        releaseProcessDefe(0);
////        deleteProcessDefe();
//    }
//
//    /**
//     * Master节点不存在，暂停/终止/恢复/重启工作流失败；
//     *
//     * @throws Exception
//     */
//    @TestUtil(timeout = 60 * 1000)
//    public void testExecute_1_1() throws Exception {
//        // TODO:
//    }
//
//    /**
//     * 流程实例不存在，暂停/终止/恢复/重启工作流失败；
//     *
//     * @throws Exception
//     */
//    @TestUtil(timeout = 60 * 1000)
//    public void testExecute_1_2() throws Exception {
//        // step1:准备阶段
//
//        // step2:执行阶段
//        ResponseMsg<Boolean> responseMsg = executorRest.execute("123456", ExecuteType.PAUSE);
//
//        // step3:验证阶段
//        Assert.assertEquals("200".equals(responseMsg.getRetCode()), false);
//
//        // step4:清理阶段
//    }
//
//    /**
//     * 流程定义不存在，暂停/终止/恢复/重启工作流失败；
//     *
//     * @throws Exception
//     */
//    @TestUtil(timeout = 60 * 1000)
//    public void testExecute_1_3() throws Exception {
//        try {
//            // step1:准备阶段:（1）创建流程定义（2）发布流程定义（3）启动流程定义；
//            // step1_1:创建流程定义 and 上线流程定义
//            createProcessDefe();
//            releaseProcessDefe(1);
//
//            // step1_2:启动流程实例；
//            startProcIns();
//
//            // step1_3:查询启动后的流程实例ID；
//            // MasterSchedulerService线程每隔1s扫描一次CMD，此处等待2s，保证ProcessInstance被创建；
//            try {
//                Thread.sleep(3000);
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//
//            String processDefinitionId = processDefeCreate.getId();
//            List<ProcessInstance> processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            ProcessInstance processInstance = processInstances.get(0);
//
//            // step2:执行阶段 and 验证阶段
//            releaseProcessDefe(0);
//            deleteProcessDefe();
//            ResponseMsg<Boolean> responseMsg = executorRest.execute(processInstance.getId(), ExecuteType.NONE);
//            Assert.assertEquals("200".equals(responseMsg.getRetCode()), false);
//
//        } finally {
//            // step3:清理阶段；（1）删除流程实例
//            deleteProcessInstance();
//        }
//    }
//
//    /**
//     * 流程定义处于OFFLINE，暂停/终止/恢复/重启工作流失败；
//     *
//     * @throws Exception
//     */
//    @TestUtil(timeout = 60 * 1000)
//    public void testExecute_1_4() throws Exception {
//        try {
//            // step1:准备阶段:（1）创建流程定义（2）发布流程定义（3）启动流程定义；
//            // step1_1:创建流程定义 and 上线流程定义
//            createProcessDefe();
//            releaseProcessDefe(1);
//
//            // step1_2:启动流程实例；
//            startProcIns();
//
//            // step1_3:查询启动后的流程实例ID；
//            // MasterSchedulerService线程每隔1s扫描一次CMD，此处等待2s，保证ProcessInstance被创建；
//            try {
//                Thread.sleep(3000);
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//
//            String processDefinitionId = processDefeCreate.getId();
//            List<ProcessInstance> processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            ProcessInstance processInstance = processInstances.get(0);
//
//            // step2:执行阶段 and 验证阶段
//            // 流程定义处于OFFLINE，不能执行execute
//            releaseProcessDefe(0);
//            ResponseMsg<Boolean> responseMsg = executorRest.execute(processInstance.getId(), ExecuteType.NONE);
//            Assert.assertEquals("200".equals(responseMsg.getRetCode()), false);
//        } finally {
//            // step3:清理阶段；（1）删除流程实例（2）删除流程定义
//            deleteProcessInstance();
//            deleteProcessDefe();
//        }
//    }
//
//    /**
//     * ExcuteType不合法，暂停/终止/恢复/重启工作流失败；
//     *
//     * @throws Exception
//     */
//    @TestUtil(timeout = 60 * 1000)
//    public void testExecute_1_5() throws Exception {
//        try {
//            // step1:准备阶段:（1）创建流程定义（2）发布流程定义（3）启动流程定义；
//            // step1_1:创建流程定义 and 上线流程定义
//            createProcessDefe();
//            releaseProcessDefe(1);
//
//            // step1_2:启动流程实例；
//            startProcIns();
//
//            // step1_3:查询启动后的流程实例ID；
//            // MasterSchedulerService线程每隔1s扫描一次CMD，此处等待2s，保证ProcessInstance被创建；
//            try {
//                Thread.sleep(3000);
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//
//            String processDefinitionId = processDefeCreate.getId();
//            List<ProcessInstance> processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            ProcessInstance processInstance = processInstances.get(0);
//
//            // step2:执行阶段
//            ResponseMsg<Boolean> responseMsg = executorRest.execute(processInstance.getId(), ExecuteType.NONE);
//
//            // step3:验证阶段
//            Assert.assertEquals("200".equals(responseMsg.getRetCode()), false);
//        } finally {
//            // step4:清理阶段；（1）删除流程定义（2）下线流程实例（3）删除流程实例
//            releaseProcessDefe(0);
//            deleteProcessInstance();
//            deleteProcessDefe();
//        }
//    }
//
//    /**
//     * Master节点不存在，暂停/终止/恢复/重启工作流失败；
//     *
//     * @throws Exception
//     */
//    @TestUtil(timeout = 60 * 1000)
//    public void testExecuteDCS_1_1() throws Exception {
//        // TODO:
//    }
//
//    /**
//     * 流程实例不存在，暂停/终止/恢复/重启工作流失败；
//     *
//     * @throws Exception
//     */
//    @TestUtil(timeout = 60 * 1000)
//    public void testExecuteDCS_1_2() throws Exception {
//        // step1:准备阶段
//
//        // step2:执行阶段
//        ResponseMsg<Boolean> responseMsg = executorRest.executeDcs("123456", ExecuteType.PAUSE);
//
//        // step3:验证阶段
//        Assert.assertEquals("200".equals(responseMsg.getRetCode()), false);
//
//        // step4:清理阶段
//    }
//
//    /**
//     * 流程定义不存在，暂停/终止/恢复/重启工作流失败；
//     *
//     * @throws Exception
//     */
//    @TestUtil(timeout = 60 * 1000)
//    public void testExecuteDCS_1_3() throws Exception {
//        try {
//            // step1:准备阶段:（1）创建流程定义（2）发布流程定义（3）启动流程定义；
//            // step1_1:创建流程定义 and 上线流程定义
//            createProcessDefe();
//            releaseProcessDefe(1);
//
//            // step1_2:启动流程实例；
//            startProcIns();
//
//            // step1_3:查询启动后的流程实例ID；
//            // MasterSchedulerService线程每隔1s扫描一次CMD，此处等待2s，保证ProcessInstance被创建；
//            try {
//                Thread.sleep(3000);
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//
//            String processDefinitionId = processDefeCreate.getId();
//            List<ProcessInstance> processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            ProcessInstance processInstance = processInstances.get(0);
//
//            // step2:执行阶段 and 验证阶段
//            releaseProcessDefe(0);
//            deleteProcessDefe();
//            ResponseMsg<Boolean> responseMsg = executorRest.executeDcs(processDefinitionId, ExecuteType.NONE);
//            Assert.assertEquals("200".equals(responseMsg.getRetCode()), false);
//
//        } finally {
//            // step3:清理阶段；（1）删除流程实例
//            deleteProcessInstance();
//        }
//    }
//
//    /**
//     * 流程定义处于OFFLINE，暂停/终止/恢复/重启工作流失败；
//     *
//     * @throws Exception
//     */
//    @TestUtil(timeout = 60 * 1000)
//    public void testExecuteDCS_1_4() throws Exception {
//        try {
//            // step1:准备阶段:（1）创建流程定义（2）发布流程定义（3）启动流程定义；
//            // step1_1:创建流程定义 and 上线流程定义
//            createProcessDefe();
//            releaseProcessDefe(1);
//
//            // step1_2:启动流程实例；
//            startProcIns();
//
//            // step1_3:查询启动后的流程实例ID；
//            // MasterSchedulerService线程每隔1s扫描一次CMD，此处等待2s，保证ProcessInstance被创建；
//            try {
//                Thread.sleep(3000);
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//
//            String processDefinitionId = processDefeCreate.getId();
//            List<ProcessInstance> processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            ProcessInstance processInstance = processInstances.get(0);
//
//            // step2:执行阶段 and 验证阶段
//            // 流程定义处于OFFLINE，不能执行execute
//            releaseProcessDefe(0);
//            ResponseMsg<Boolean> responseMsg = executorRest.executeDcs(processDefinitionId, ExecuteType.NONE);
//            Assert.assertEquals("200".equals(responseMsg.getRetCode()), false);
//        } finally {
//            // step3:清理阶段；（1）删除流程实例（2）删除流程定义
//            deleteProcessInstance();
//            deleteProcessDefe();
//        }
//    }
//
//    /**
//     * ExcuteType不合法，暂停/终止/恢复/重启工作流失败；
//     *
//     * @throws Exception
//     */
//    @TestUtil(timeout = 60 * 1000)
//    public void testExecuteDCS_1_5() throws Exception {
//        try {
//            // step1:准备阶段:（1）创建流程定义（2）发布流程定义（3）启动流程定义；
//            // step1_1:创建流程定义 and 上线流程定义
//            createProcessDefe();
//            releaseProcessDefe(1);
//
//            // step1_2:启动流程实例；
//            startProcIns();
//
//            // step1_3:查询启动后的流程实例ID；
//            // MasterSchedulerService线程每隔1s扫描一次CMD，此处等待2s，保证ProcessInstance被创建；
//            try {
//                Thread.sleep(3000);
//            } catch (Exception e) {
//                e.printStackTrace();
//            }
//
//            String processDefinitionId = processDefeCreate.getId();
//            List<ProcessInstance> processInstances = processInstanceMapper.queryByProcessDefineId(processDefinitionId, 1);
//            if (processInstances == null || processInstances.size() <= 0) {
//                Assert.assertEquals(true, false);
//            }
//            ProcessInstance processInstance = processInstances.get(0);
//
//            // step2:执行阶段
//            ResponseMsg<Boolean> responseMsg = executorRest.executeDcs(processDefinitionId, ExecuteType.NONE);
//
//            // step3:验证阶段
//            Assert.assertEquals("200".equals(responseMsg.getRetCode()), false);
//        } finally {
//            // step4:清理阶段；（1）删除流程定义（2）下线流程实例（3）删除流程实例
//            releaseProcessDefe(0);
//            deleteProcessInstance();
//            deleteProcessDefe();
//        }
//    }

}
